home *** CD-ROM | disk | FTP | other *** search
/ Erotic Games: Memory / Erotic Games: Memory.iso / mac / air_installers / AdobeAIR.exe / setup.swf / scripts / mx / collections / ModifiedCollectionView.as < prev    next >
Text File  |  2009-02-12  |  27KB  |  871 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.utils.Dictionary;
  5.    import mx.collections.errors.CollectionViewError;
  6.    import mx.core.mx_internal;
  7.    import mx.events.CollectionEvent;
  8.    import mx.events.CollectionEventKind;
  9.    import mx.events.PropertyChangeEvent;
  10.    import mx.resources.IResourceManager;
  11.    import mx.resources.ResourceManager;
  12.    
  13.    use namespace mx_internal;
  14.    
  15.    public class ModifiedCollectionView implements ICollectionView
  16.    {
  17.       
  18.       public static const REPLACEMENT:String = "replacement";
  19.       
  20.       public static const REPLACED:String = "replaced";
  21.       
  22.       public static const REMOVED:String = "removed";
  23.       
  24.       mx_internal static const VERSION:String = "3.0.0.0";
  25.       
  26.       public static const ADDED:String = "added";
  27.        
  28.       
  29.       private var addedItems:Dictionary;
  30.       
  31.       private var _showPreserved:Boolean = false;
  32.       
  33.       private var list:ICollectionView;
  34.       
  35.       private var deltaLength:int = 0;
  36.       
  37.       private var resourceManager:IResourceManager;
  38.       
  39.       private var removedItems:Dictionary;
  40.       
  41.       private var itemWrappersByIndex:Array;
  42.       
  43.       private var replacementItems:Dictionary;
  44.       
  45.       private var deltas:Array;
  46.       
  47.       private var replacedItems:Dictionary;
  48.       
  49.       private var itemWrappersByCollectionMod:Dictionary;
  50.       
  51.       public function ModifiedCollectionView(param1:ICollectionView)
  52.       {
  53.          resourceManager = ResourceManager.getInstance();
  54.          deltas = [];
  55.          removedItems = new Dictionary(true);
  56.          addedItems = new Dictionary(true);
  57.          replacedItems = new Dictionary(true);
  58.          replacementItems = new Dictionary(true);
  59.          itemWrappersByIndex = [];
  60.          itemWrappersByCollectionMod = new Dictionary(true);
  61.          super();
  62.          this.list = param1;
  63.       }
  64.       
  65.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  66.       {
  67.          var _loc3_:String = null;
  68.          if(!(param1 is ModifiedCollectionViewBookmark) || ModifiedCollectionViewBookmark(param1).view != this)
  69.          {
  70.             _loc3_ = resourceManager.getString("collections","bookmarkNotFound");
  71.             throw new CollectionViewError(_loc3_);
  72.          }
  73.          var _loc2_:ModifiedCollectionViewBookmark = ModifiedCollectionViewBookmark(param1);
  74.          return _loc2_.index;
  75.       }
  76.       
  77.       public function willTrigger(param1:String) : Boolean
  78.       {
  79.          return false;
  80.       }
  81.       
  82.       private function removeModification(param1:CollectionModification) : Boolean
  83.       {
  84.          var _loc2_:int = 0;
  85.          while(_loc2_ < deltas.length)
  86.          {
  87.             if(deltas[_loc2_] == param1)
  88.             {
  89.                deltas.splice(_loc2_,1);
  90.                return true;
  91.             }
  92.             _loc2_++;
  93.          }
  94.          return false;
  95.       }
  96.       
  97.       mx_internal function getWrappedItemUsingCursor(param1:ModifiedCollectionViewCursor, param2:int) : Object
  98.       {
  99.          var _loc6_:CollectionModification = null;
  100.          var _loc9_:Object = null;
  101.          var _loc3_:int = param2;
  102.          var _loc4_:Object = null;
  103.          var _loc5_:CollectionModification = null;
  104.          var _loc7_:Boolean = false;
  105.          var _loc8_:int = 0;
  106.          while(_loc8_ < deltas.length)
  107.          {
  108.             _loc6_ = deltas[_loc8_];
  109.             if(_loc3_ < _loc6_.index)
  110.             {
  111.                break;
  112.             }
  113.             if(_loc6_.modificationType == CollectionModification.REPLACE)
  114.             {
  115.                if(_loc3_ == _loc6_.index && _loc6_.showOldReplace && _showPreserved)
  116.                {
  117.                   _loc5_ = _loc6_;
  118.                   break;
  119.                }
  120.                if(_loc3_ == _loc6_.index + 1 && _loc6_.showOldReplace && _loc6_.showNewReplace && _showPreserved)
  121.                {
  122.                   _loc3_--;
  123.                   _loc7_ = true;
  124.                   break;
  125.                }
  126.                if(_loc3_ == _loc6_.index && (!_loc6_.showOldReplace && _loc6_.showNewReplace || !_showPreserved))
  127.                {
  128.                   _loc7_ = true;
  129.                   break;
  130.                }
  131.                _loc3_ -= _loc6_.modCount;
  132.             }
  133.             else if(isActive(_loc6_))
  134.             {
  135.                if(_loc3_ == _loc6_.index && _loc6_.isRemove)
  136.                {
  137.                   _loc5_ = _loc6_;
  138.                   break;
  139.                }
  140.                if(_loc3_ >= _loc6_.index)
  141.                {
  142.                   _loc3_ -= _loc6_.modCount;
  143.                }
  144.             }
  145.             _loc8_++;
  146.          }
  147.          if(_loc5_)
  148.          {
  149.             _loc4_ = _loc5_.item;
  150.          }
  151.          else
  152.          {
  153.             param1.internalCursor.seek(CursorBookmark.CURRENT,_loc3_ - param1.internalIndex);
  154.             _loc4_ = param1.internalCursor.current;
  155.             param1.internalIndex = _loc3_;
  156.          }
  157.          if(_loc6_ && _loc3_ == _loc6_.index && _loc6_.modificationType == CollectionModification.ADD)
  158.          {
  159.             _loc9_ = getUniqueItemWrapper(_loc4_,_loc6_,_loc3_);
  160.          }
  161.          else
  162.          {
  163.             _loc9_ = getUniqueItemWrapper(_loc4_,_loc5_,_loc3_);
  164.          }
  165.          return _loc9_;
  166.       }
  167.       
  168.       public function contains(param1:Object) : Boolean
  169.       {
  170.          return false;
  171.       }
  172.       
  173.       private function integrateReplacedElements(param1:CollectionEvent, param2:int, param3:int) : void
  174.       {
  175.          var _loc9_:Object = null;
  176.          var _loc10_:Object = null;
  177.          var _loc11_:CollectionModification = null;
  178.          var _loc12_:CollectionModification = null;
  179.          var _loc4_:int = 0;
  180.          var _loc5_:int = 0;
  181.          var _loc6_:Boolean = false;
  182.          var _loc7_:int = param1.items.length;
  183.          var _loc8_:int = 0;
  184.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  185.          {
  186.             _loc9_ = PropertyChangeEvent(param1.items[_loc5_]).oldValue;
  187.             _loc10_ = PropertyChangeEvent(param1.items[_loc5_]).newValue;
  188.             _loc11_ = CollectionModification(deltas[_loc4_]);
  189.             _loc12_ = new CollectionModification(param1.location + _loc5_,_loc9_,CollectionModification.REPLACE);
  190.             if(_loc11_.isRemove && _loc11_.index <= _loc12_.index || !_loc11_.isRemove && _loc11_.index < _loc12_.index)
  191.             {
  192.                _loc4_++;
  193.             }
  194.             else if((_loc11_.modificationType == CollectionModification.ADD || _loc11_.modificationType == CollectionModification.REPLACE) && _loc11_.index == _loc12_.index)
  195.             {
  196.                _loc4_++;
  197.                _loc5_++;
  198.             }
  199.             else
  200.             {
  201.                deltas.splice(_loc4_ + _loc5_,0,_loc12_);
  202.                replacedItems[getUniqueItemWrapper(_loc9_,_loc12_,param1.location + _loc5_)] = _loc12_;
  203.                replacementItems[getUniqueItemWrapper(_loc10_,_loc12_,param1.location + _loc5_,true)] = _loc12_;
  204.                _loc5_++;
  205.                _loc4_++;
  206.             }
  207.          }
  208.          while(_loc5_ < _loc7_)
  209.          {
  210.             _loc9_ = PropertyChangeEvent(param1.items[_loc5_]).oldValue;
  211.             _loc10_ = PropertyChangeEvent(param1.items[_loc5_]).newValue;
  212.             deltas.push(_loc12_ = new CollectionModification(param1.location + _loc5_,_loc9_,CollectionModification.REPLACE));
  213.             replacedItems[getUniqueItemWrapper(_loc9_,_loc12_,param1.location + _loc5_)] = _loc12_;
  214.             replacementItems[getUniqueItemWrapper(_loc10_,_loc12_,param1.location + _loc5_,true)] = _loc12_;
  215.             _loc5_++;
  216.          }
  217.       }
  218.       
  219.       mx_internal function getBookmark(param1:ModifiedCollectionViewCursor) : ModifiedCollectionViewBookmark
  220.       {
  221.          var _loc4_:String = null;
  222.          var _loc2_:int = param1.currentIndex;
  223.          if(_loc2_ < 0 || _loc2_ > length)
  224.          {
  225.             _loc4_ = resourceManager.getString("collections","invalidIndex",[_loc2_]);
  226.             throw new CollectionViewError(_loc4_);
  227.          }
  228.          var _loc3_:Object = param1.current;
  229.          return new ModifiedCollectionViewBookmark(_loc3_,this,0,_loc2_,param1.internalCursor.bookmark,param1.internalIndex);
  230.       }
  231.       
  232.       public function get sort() : Sort
  233.       {
  234.          return null;
  235.       }
  236.       
  237.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  238.       {
  239.       }
  240.       
  241.       public function processCollectionEvent(param1:CollectionEvent, param2:int, param3:int) : void
  242.       {
  243.          switch(param1.kind)
  244.          {
  245.             case CollectionEventKind.ADD:
  246.                integrateAddedElements(param1,param2,param3);
  247.                break;
  248.             case CollectionEventKind.REMOVE:
  249.                integrateRemovedElements(param1,param2,param3);
  250.                break;
  251.             case CollectionEventKind.REPLACE:
  252.                integrateReplacedElements(param1,param2,param3);
  253.          }
  254.       }
  255.       
  256.       public function get showPreservedState() : Boolean
  257.       {
  258.          return _showPreserved;
  259.       }
  260.       
  261.       public function getSemantics(param1:ItemWrapper) : String
  262.       {
  263.          if(removedItems[param1])
  264.          {
  265.             return ModifiedCollectionView.REMOVED;
  266.          }
  267.          if(addedItems[param1])
  268.          {
  269.             return ModifiedCollectionView.ADDED;
  270.          }
  271.          if(replacedItems[param1])
  272.          {
  273.             return ModifiedCollectionView.REPLACED;
  274.          }
  275.          if(replacementItems[param1])
  276.          {
  277.             return ModifiedCollectionView.REPLACEMENT;
  278.          }
  279.          return null;
  280.       }
  281.       
  282.       private function getUniqueItemWrapper(param1:Object, param2:CollectionModification, param3:int, param4:Boolean = false) : Object
  283.       {
  284.          if(param2 && (param2.isRemove || param2.modificationType == CollectionModification.REPLACE && !param4))
  285.          {
  286.             if(!itemWrappersByCollectionMod[param2])
  287.             {
  288.                itemWrappersByCollectionMod[param2] = new ItemWrapper(param1);
  289.             }
  290.             return itemWrappersByCollectionMod[param2];
  291.          }
  292.          if(param2 && param2.modificationType == CollectionModification.ADD)
  293.          {
  294.             param3 = param2.index;
  295.          }
  296.          if(!itemWrappersByIndex[param3])
  297.          {
  298.             itemWrappersByIndex[param3] = new ItemWrapper(param1);
  299.          }
  300.          return itemWrappersByIndex[param3];
  301.       }
  302.       
  303.       public function enableAutoUpdate() : void
  304.       {
  305.       }
  306.       
  307.       public function set sort(param1:Sort) : void
  308.       {
  309.       }
  310.       
  311.       public function removeItem(param1:ItemWrapper) : void
  312.       {
  313.          var _loc2_:CollectionModification = removedItems[param1] as CollectionModification;
  314.          if(!_loc2_)
  315.          {
  316.             _loc2_ = replacedItems[param1] as CollectionModification;
  317.             if(_loc2_)
  318.             {
  319.                delete replacedItems[param1];
  320.                _loc2_.stopShowingReplacedValue();
  321.                --deltaLength;
  322.                if(_loc2_.modCount == 0)
  323.                {
  324.                   removeModification(_loc2_);
  325.                }
  326.             }
  327.          }
  328.          else if(removeModification(_loc2_))
  329.          {
  330.             delete removedItems[param1];
  331.             --deltaLength;
  332.          }
  333.       }
  334.       
  335.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  336.       {
  337.       }
  338.       
  339.       private function integrateRemovedElements(param1:CollectionEvent, param2:int, param3:int) : void
  340.       {
  341.          var _loc9_:CollectionModification = null;
  342.          var _loc10_:CollectionModification = null;
  343.          var _loc4_:int = 0;
  344.          var _loc5_:int = 0;
  345.          var _loc6_:int = 0;
  346.          var _loc7_:int = param1.items.length;
  347.          var _loc8_:int = 0;
  348.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  349.          {
  350.             _loc9_ = CollectionModification(deltas[_loc4_]);
  351.             _loc10_ = new CollectionModification(param1.location,param1.items[_loc5_],CollectionModification.REMOVE);
  352.             removedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  353.             if(_loc8_ != 0)
  354.             {
  355.                _loc9_.index += _loc8_;
  356.             }
  357.             if(_loc9_.isRemove && _loc9_.index <= _loc10_.index || !_loc9_.isRemove && _loc9_.index < _loc10_.index)
  358.             {
  359.                _loc4_++;
  360.             }
  361.             else
  362.             {
  363.                if(!_loc9_.isRemove && _loc9_.index == _loc10_.index)
  364.                {
  365.                   deltas.splice(_loc4_ + _loc5_,1);
  366.                }
  367.                else
  368.                {
  369.                   deltas.splice(_loc4_ + _loc5_,0,_loc10_);
  370.                   _loc4_++;
  371.                }
  372.                _loc8_--;
  373.                _loc5_++;
  374.             }
  375.          }
  376.          while(_loc4_ < deltas.length)
  377.          {
  378.             _loc9_ = CollectionModification(deltas[_loc4_++]);
  379.             _loc9_.index += _loc8_;
  380.          }
  381.          while(_loc5_ < _loc7_)
  382.          {
  383.             deltas.push(_loc10_ = new CollectionModification(param1.location,param1.items[_loc5_],CollectionModification.REMOVE));
  384.             removedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  385.             _loc5_++;
  386.          }
  387.          deltaLength += param1.items.length - _loc6_;
  388.       }
  389.       
  390.       public function dispatchEvent(param1:Event) : Boolean
  391.       {
  392.          return false;
  393.       }
  394.       
  395.       private function isActive(param1:CollectionModification) : Boolean
  396.       {
  397.          return _showPreserved;
  398.       }
  399.       
  400.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0.0, param5:Boolean = false) : void
  401.       {
  402.       }
  403.       
  404.       public function refresh() : Boolean
  405.       {
  406.          return false;
  407.       }
  408.       
  409.       public function addItem(param1:ItemWrapper) : void
  410.       {
  411.          var _loc2_:CollectionModification = addedItems[param1] as CollectionModification;
  412.          if(!_loc2_)
  413.          {
  414.             _loc2_ = replacementItems[param1] as CollectionModification;
  415.             if(_loc2_)
  416.             {
  417.                _loc2_.startShowingReplacementValue();
  418.                ++deltaLength;
  419.                if(_loc2_.modCount == 0)
  420.                {
  421.                   removeModification(_loc2_);
  422.                }
  423.             }
  424.          }
  425.          else if(removeModification(_loc2_))
  426.          {
  427.             ++deltaLength;
  428.          }
  429.       }
  430.       
  431.       public function get length() : int
  432.       {
  433.          return list.length + (!!_showPreserved ? deltaLength : 0);
  434.       }
  435.       
  436.       public function set filterFunction(param1:Function) : void
  437.       {
  438.       }
  439.       
  440.       public function set showPreservedState(param1:Boolean) : void
  441.       {
  442.          _showPreserved = param1;
  443.       }
  444.       
  445.       public function createCursor() : IViewCursor
  446.       {
  447.          var _loc1_:IViewCursor = list.createCursor();
  448.          var _loc2_:Object = _loc1_.current;
  449.          return new ModifiedCollectionViewCursor(this,_loc1_,_loc2_);
  450.       }
  451.       
  452.       private function integrateAddedElements(param1:CollectionEvent, param2:int, param3:int) : void
  453.       {
  454.          var _loc9_:CollectionModification = null;
  455.          var _loc10_:CollectionModification = null;
  456.          var _loc4_:int = 0;
  457.          var _loc5_:int = 0;
  458.          var _loc6_:Boolean = false;
  459.          var _loc7_:int = param1.items.length;
  460.          var _loc8_:int = 0;
  461.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  462.          {
  463.             _loc9_ = CollectionModification(deltas[_loc4_]);
  464.             _loc10_ = new CollectionModification(param1.location + _loc5_,null,CollectionModification.ADD);
  465.             addedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  466.             if(_loc9_.isRemove && _loc9_.index <= _loc10_.index || !_loc9_.isRemove && _loc9_.index < _loc10_.index)
  467.             {
  468.                _loc4_++;
  469.             }
  470.             else
  471.             {
  472.                deltas.splice(_loc4_ + _loc5_,0,_loc10_);
  473.                _loc8_++;
  474.                _loc5_++;
  475.                _loc4_++;
  476.             }
  477.          }
  478.          while(_loc4_ < deltas.length)
  479.          {
  480.             _loc9_ = CollectionModification(deltas[_loc4_++]);
  481.             _loc9_.index += _loc8_;
  482.          }
  483.          while(_loc5_ < _loc7_)
  484.          {
  485.             deltas.push(_loc10_ = new CollectionModification(param1.location + _loc5_,null,CollectionModification.ADD));
  486.             addedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  487.             _loc5_++;
  488.          }
  489.          deltaLength -= param1.items.length;
  490.       }
  491.       
  492.       public function disableAutoUpdate() : void
  493.       {
  494.       }
  495.       
  496.       public function hasEventListener(param1:String) : Boolean
  497.       {
  498.          return false;
  499.       }
  500.       
  501.       public function get filterFunction() : Function
  502.       {
  503.          return null;
  504.       }
  505.    }
  506. }
  507.  
  508. import mx.collections.CursorBookmark;
  509. import mx.collections.ModifiedCollectionView;
  510. import mx.core.mx_internal;
  511.  
  512. use namespace mx_internal;
  513.  
  514. class ModifiedCollectionViewBookmark extends CursorBookmark
  515. {
  516.     
  517.    
  518.    mx_internal var viewRevision:int;
  519.    
  520.    mx_internal var index:int;
  521.    
  522.    mx_internal var internalBookmark:CursorBookmark;
  523.    
  524.    mx_internal var view:ModifiedCollectionView;
  525.    
  526.    mx_internal var internalIndex:int;
  527.    
  528.    function ModifiedCollectionViewBookmark(param1:Object, param2:ModifiedCollectionView, param3:int, param4:int, param5:CursorBookmark, param6:int)
  529.    {
  530.       super(param1);
  531.       this.view = param2;
  532.       this.viewRevision = param3;
  533.       this.index = param4;
  534.       this.internalBookmark = param5;
  535.       this.internalIndex = param6;
  536.    }
  537.    
  538.    override public function getViewIndex() : int
  539.    {
  540.       return mx_internal::view.getBookmarkIndex(this);
  541.    }
  542. }
  543.  
  544. import flash.events.EventDispatcher;
  545. import mx.collections.CursorBookmark;
  546. import mx.collections.ICollectionView;
  547. import mx.collections.IViewCursor;
  548. import mx.collections.ModifiedCollectionView;
  549. import mx.collections.errors.CollectionViewError;
  550. import mx.collections.errors.CursorError;
  551. import mx.collections.errors.ItemPendingError;
  552. import mx.core.mx_internal;
  553. import mx.events.FlexEvent;
  554. import mx.resources.IResourceManager;
  555. import mx.resources.ResourceManager;
  556.  
  557. use namespace mx_internal;
  558.  
  559. class ModifiedCollectionViewCursor extends EventDispatcher implements IViewCursor
  560. {
  561.    
  562.    private static const BEFORE_FIRST_INDEX:int = -1;
  563.    
  564.    private static const AFTER_LAST_INDEX:int = -2;
  565.     
  566.    
  567.    private var _view:ModifiedCollectionView;
  568.    
  569.    private var resourceManager:IResourceManager;
  570.    
  571.    public var internalIndex:int;
  572.    
  573.    mx_internal var currentIndex:int;
  574.    
  575.    public var internalCursor:IViewCursor;
  576.    
  577.    private var invalid:Boolean;
  578.    
  579.    private var currentValue:Object;
  580.    
  581.    function ModifiedCollectionViewCursor(param1:ModifiedCollectionView, param2:IViewCursor, param3:Object)
  582.    {
  583.       var view:ModifiedCollectionView = param1;
  584.       var cursor:IViewCursor = param2;
  585.       var current:Object = param3;
  586.       resourceManager = ResourceManager.getInstance();
  587.       super();
  588.       _view = view;
  589.       internalCursor = cursor;
  590.       if(cursor.beforeFirst && !current)
  591.       {
  592.          internalIndex = BEFORE_FIRST_INDEX;
  593.       }
  594.       else if(cursor.afterLast && !current)
  595.       {
  596.          internalIndex = AFTER_LAST_INDEX;
  597.       }
  598.       else
  599.       {
  600.          internalIndex = 0;
  601.       }
  602.       currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  603.       if(mx_internal::currentIndex == 0)
  604.       {
  605.          try
  606.          {
  607.             setCurrent(current,false);
  608.          }
  609.          catch(e:ItemPendingError)
  610.          {
  611.             currentIndex = BEFORE_FIRST_INDEX;
  612.             setCurrent(null,false);
  613.          }
  614.       }
  615.    }
  616.    
  617.    public function findAny(param1:Object) : Boolean
  618.    {
  619.       return false;
  620.    }
  621.    
  622.    public function findFirst(param1:Object) : Boolean
  623.    {
  624.       return false;
  625.    }
  626.    
  627.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  628.    {
  629.       var message:String = null;
  630.       var mcvBookmark:ModifiedCollectionViewBookmark = null;
  631.       var bookmark:CursorBookmark = param1;
  632.       var offset:int = param2;
  633.       var prefetch:int = param3;
  634.       checkValid();
  635.       if(view.length == 0)
  636.       {
  637.          currentIndex = AFTER_LAST_INDEX;
  638.          setCurrent(null,false);
  639.          return;
  640.       }
  641.       var newIndex:int = mx_internal::currentIndex;
  642.       if(bookmark == CursorBookmark.FIRST)
  643.       {
  644.          newIndex = 0;
  645.          internalIndex = 0;
  646.          internalCursor.seek(CursorBookmark.FIRST);
  647.       }
  648.       else if(bookmark == CursorBookmark.LAST)
  649.       {
  650.          newIndex = view.length - 1;
  651.          internalCursor.seek(CursorBookmark.LAST);
  652.       }
  653.       else if(bookmark != CursorBookmark.CURRENT)
  654.       {
  655.          try
  656.          {
  657.             mcvBookmark = bookmark as ModifiedCollectionViewBookmark;
  658.             newIndex = ModifiedCollectionView(view).getBookmarkIndex(bookmark);
  659.             if(!mcvBookmark || newIndex < 0)
  660.             {
  661.                setCurrent(null);
  662.                message = resourceManager.getString("collections","bookmarkInvalid");
  663.                throw new CursorError(message);
  664.             }
  665.             internalIndex = mcvBookmark.internalIndex;
  666.             internalCursor.seek(mcvBookmark.internalBookmark);
  667.          }
  668.          catch(bmError:CollectionViewError)
  669.          {
  670.             message = resourceManager.getString("collections","bookmarkInvalid");
  671.             throw new CursorError(message);
  672.          }
  673.       }
  674.       newIndex += offset;
  675.       var newCurrent:Object = null;
  676.       if(newIndex >= view.length)
  677.       {
  678.          currentIndex = AFTER_LAST_INDEX;
  679.       }
  680.       else if(newIndex < 0)
  681.       {
  682.          currentIndex = BEFORE_FIRST_INDEX;
  683.       }
  684.       else
  685.       {
  686.          newCurrent = ModifiedCollectionView(view).getWrappedItemUsingCursor(this,newIndex);
  687.          currentIndex = newIndex;
  688.       }
  689.       setCurrent(newCurrent);
  690.    }
  691.    
  692.    public function insert(param1:Object) : void
  693.    {
  694.    }
  695.    
  696.    [Bindable("cursorUpdate")]
  697.    public function get afterLast() : Boolean
  698.    {
  699.       checkValid();
  700.       return mx_internal::currentIndex == AFTER_LAST_INDEX || view.length == 0;
  701.    }
  702.    
  703.    public function remove() : Object
  704.    {
  705.       return null;
  706.    }
  707.    
  708.    private function checkValid() : void
  709.    {
  710.       var _loc1_:String = null;
  711.       if(invalid)
  712.       {
  713.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  714.          throw new CursorError(_loc1_);
  715.       }
  716.    }
  717.    
  718.    public function get view() : ICollectionView
  719.    {
  720.       checkValid();
  721.       return _view;
  722.    }
  723.    
  724.    public function movePrevious() : Boolean
  725.    {
  726.       if(beforeFirst)
  727.       {
  728.          return false;
  729.       }
  730.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(mx_internal::currentIndex - 1);
  731.       if(_loc1_ == -1)
  732.       {
  733.          _loc1_ = BEFORE_FIRST_INDEX;
  734.          setCurrent(null);
  735.       }
  736.       else
  737.       {
  738.          setCurrent(ModifiedCollectionView(view).getWrappedItemUsingCursor(this,_loc1_));
  739.       }
  740.       currentIndex = _loc1_;
  741.       return !beforeFirst;
  742.    }
  743.    
  744.    public function moveNext() : Boolean
  745.    {
  746.       if(afterLast)
  747.       {
  748.          return false;
  749.       }
  750.       var _loc1_:int = !!beforeFirst ? 0 : int(mx_internal::currentIndex + 1);
  751.       if(_loc1_ >= view.length)
  752.       {
  753.          _loc1_ = AFTER_LAST_INDEX;
  754.          setCurrent(null);
  755.       }
  756.       else
  757.       {
  758.          setCurrent(ModifiedCollectionView(view).getWrappedItemUsingCursor(this,_loc1_));
  759.       }
  760.       currentIndex = _loc1_;
  761.       return !afterLast;
  762.    }
  763.    
  764.    public function findLast(param1:Object) : Boolean
  765.    {
  766.       return false;
  767.    }
  768.    
  769.    [Bindable("cursorUpdate")]
  770.    public function get beforeFirst() : Boolean
  771.    {
  772.       checkValid();
  773.       return mx_internal::currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  774.    }
  775.    
  776.    [Bindable("cursorUpdate")]
  777.    public function get bookmark() : CursorBookmark
  778.    {
  779.       checkValid();
  780.       if(view.length == 0 || beforeFirst)
  781.       {
  782.          return CursorBookmark.FIRST;
  783.       }
  784.       if(afterLast)
  785.       {
  786.          return CursorBookmark.LAST;
  787.       }
  788.       return ModifiedCollectionView(view).getBookmark(this);
  789.    }
  790.    
  791.    [Bindable("cursorUpdate")]
  792.    public function get current() : Object
  793.    {
  794.       checkValid();
  795.       return currentValue;
  796.    }
  797.    
  798.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  799.    {
  800.       currentValue = param1;
  801.       if(param2)
  802.       {
  803.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  804.       }
  805.    }
  806. }
  807.  
  808. class CollectionModification
  809. {
  810.    
  811.    public static const ADD:String = "add";
  812.    
  813.    public static const REPLACE:String = "replace";
  814.    
  815.    public static const REMOVE:String = "remove";
  816.     
  817.    
  818.    public var showOldReplace:Boolean = true;
  819.    
  820.    private var _modCount:int = 0;
  821.    
  822.    public var showNewReplace:Boolean = false;
  823.    
  824.    public var index:int;
  825.    
  826.    public var modificationType:String = null;
  827.    
  828.    public var item:Object = null;
  829.    
  830.    function CollectionModification(param1:int, param2:Object, param3:String)
  831.    {
  832.       super();
  833.       this.index = param1;
  834.       this.modificationType = param3;
  835.       if(param3 != CollectionModification.ADD)
  836.       {
  837.          this.item = param2;
  838.       }
  839.       if(param3 == CollectionModification.REMOVE)
  840.       {
  841.          _modCount = 1;
  842.       }
  843.       else if(param3 == CollectionModification.ADD)
  844.       {
  845.          _modCount = -1;
  846.       }
  847.    }
  848.    
  849.    public function startShowingReplacementValue() : void
  850.    {
  851.       showNewReplace = true;
  852.       ++_modCount;
  853.    }
  854.    
  855.    public function get modCount() : int
  856.    {
  857.       return _modCount;
  858.    }
  859.    
  860.    public function get isRemove() : Boolean
  861.    {
  862.       return modificationType == CollectionModification.REMOVE;
  863.    }
  864.    
  865.    public function stopShowingReplacedValue() : void
  866.    {
  867.       showOldReplace = false;
  868.       --_modCount;
  869.    }
  870. }
  871.